package comone.javafour;

public class Demo {
    /*优化：对程序优化
    * 面向对象三大核心:封装，继承，多态
    * 一：封装：----安全
    *       广义：对业务的封装。
    *       狭义：给对象属性私有化，提供get和set方法以便于访问。
    *     1:访问修饰符：
                private	    可以	不可以	不可以	不可以
                默认修饰符	可以	可以	（子类父子不同包）不可以	不可以
                protected	可以	可以	可以	不可以
                public	    可以	可以	可以	可以

          2:static:静态关键字
             1):能干什么：修饰成员属性，成员方法，代码块
             2):为什么用：为了不需要实力对象，就想访问类中的属性和方法。
             3):怎么用：static

           static修饰变量/类变量：
                  全局共享 就只有一份拷贝。
                  类内部，可在任何方法内直接访问静态变量。
                  其他类中，可以直接通过类名访问。
           static修饰方法/静态方法
                  可直接通过类名访问。
                  可以调用静态方法和属性，不能调用非静态的方法和属性。
           static修饰代码块：
                  只加载一次，优先加载，多个按单块顺序加载

      二：继承：代码冗余----思想性的
                广义：使用继承设计程序业务模块。
                狭义：在练习中继承的实现过程，了解继承的具体实现方式。

            1):哪些能继承：
                1：非私有的属性和行为

            2):哪些不能继承：
                1：私有的属性和行为。
                2：静态方法不参与继承。
                3：构造方法不能被继承，但是可以在子类中被调用
                        注意：只能在子类中的构造方法的第一句使用supper关键字调用,
                           子类会默认自动调用父类的无参构造,除非子类显示调用父类的有参构造。

            3):继承的特性：单根性，一个子类只能有一个直接的父类，具备延续性。
                        注意：任何类都有一个基类Object

            4):继承怎么实现：使用extends关键字完成继承。

            5):继承后如何访问父类的属性和行为：this supper关键字。
                         this:子类对象，supper：父类对象

            6): 何时使用：符合is-a关系的设计使用继承

            7):继承应用场景：
                1>：两个或者两个以上的类，不相同的属性和方法。
                  抽离出来封装成一个父类，由子类进行继承。
                2>：为程序统一设置相同行为方法。
                3>：当前对象的行为不满足使用，可以直接继承其他有相似行为的类，
                    拓展本类的行为。

            8):重写：当父类的行为不满足，子类的需要时，子类会选择重写这个行为。
                 注意：子类重写父类的行为，当进行到用时，不会再调用父类的行为了。

                特征-->前提：发生在两个或以上的类：
                    1：方法名相同。
                    2：参数列表相同。
                    3：返回值类型相同或者是其子类。
                    4：父类的静态方法不能被子类覆盖为非静态方法,父类的非静态方法不能被子类覆盖为静态方法。
                    5：子类可以定义与父类同名的静态方法，以便在子类中隐藏父类的静态方法(注：静态方法中无法使用super).
                    6：父类的私有方法不能被子类覆盖。
                    7：不能抛出比父类方法更多的异常。
                    8：访问权限不能严于父类。

                重载和重写区别：
                    重载：发送在一个类。
                    重写：发生在两个或以上的类：

               比较 ==和equals的区别：
                  equals：只能用于比较引用数据类型，用来比较地址，但是如果String类的话
                    用来比较值。
                  ==：
                    如果用来比较引用数据类型，比较的是地址。
                    如果用来比较基本数据类型，比较的是值。



      三：多态：是一个行为的不同的转态。----->是特殊应用场景下的技术
             原则：重写是多态的基础（前提）。

             应用场景：
                1：父类当形参,传递子类的实例。
                2：父类但返回值类型--父类接收子类实例。
            向上转型：父类接收子类。
            向下转型：父类转转子类。
            *
             instanceof :用来判断一个实例是否是某个类立体实例。

      四：抽象类和抽象方法：解决代码冗余
                抽象方法：使用了重写，使用了多态思想前提下使用。
                如何使用：使用 abstract来修饰。
                抽象类：有抽象方法的类必须是抽象类。
                特征：
                     1：抽象方法必须出现在抽象类中。
                     2：抽象方法必须在子类中被重写，除非子类也是一个抽象类。
                     3：抽象方法没有方法体。
                     4：抽象类中可以有非抽象方法。
                     5：抽象类不被实例化。
                抽象类和普通类区别：
                    1：抽象类不能被实例化，普通类可以吧。
                    2：抽象类有抽象方法，普通类没有。
                    3：抽象类中的抽象方法，必须别子类重写，普通类方法不需要。


     *
     *
     *
     * */
}
